home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2000 #5 / Amiga Plus CD - 2000 - No. 5.iso / Tools / Dev / lame_src / reservoir.c < prev    next >
C/C++ Source or Header  |  2000-01-01  |  5KB  |  175 lines
  1. #include <assert.h>
  2. #include "util.h"
  3.  
  4.  
  5.  
  6. /*
  7.   ResvFrameBegin:
  8.   Called (repeatedly) at the beginning of a frame. Updates the maximum
  9.   size of the reservoir, and checks to make sure main_data_begin
  10.   was set properly by the formatter
  11. */
  12. int
  13. ResvFrameBegin(lame_global_flags *gfp,III_side_info_t *l3_side, int mean_bits, int frameLength )
  14. {
  15.     lame_internal_flags *gfc=gfp->internal_flags;
  16.     int fullFrameBits;
  17.     int resvLimit;
  18.     int maxmp3buf;
  19.  
  20.  
  21.     /* main_data_begin has 9 bits in MPEG 1, 8 bits MPEG2 */
  22.     resvLimit = (gfp->version==1) ? 4088 : 2040 ;
  23.  
  24.  
  25.     /* maximum allowed frame size */
  26.     if (gfp->strict_ISO)
  27.       maxmp3buf = 8*960;
  28.     else
  29.       maxmp3buf = 8*2047;
  30.  
  31.     if ( frameLength > maxmp3buf )
  32.     gfc->ResvMax = 0;
  33.     else
  34.     gfc->ResvMax = maxmp3buf - frameLength;
  35.     if (gfp->disable_reservoir) gfc->ResvMax=0;
  36.     if ( gfc->ResvMax > resvLimit ) gfc->ResvMax = resvLimit;
  37.     assert(0==(gfc->ResvMax % 8));
  38.  
  39.     l3_side->resvDrain_pre = 0;
  40.  
  41.     if (gfc->pinfo != NULL){
  42.       gfc->pinfo->mean_bits=mean_bits/2;  /* expected bits per channel per granule */
  43.       gfc->pinfo->resvsize=gfc->ResvSize;
  44.     }
  45.  
  46.     fullFrameBits = mean_bits * gfc->mode_gr + Min(gfc->ResvSize,gfc->ResvMax);
  47.     if (gfp->strict_ISO) {
  48.       if (fullFrameBits>maxmp3buf) fullFrameBits=maxmp3buf;
  49.     }
  50.     return fullFrameBits;
  51. }
  52.  
  53.  
  54. /*
  55.   ResvMaxBits
  56.   returns targ_bits:  target number of bits to use for 1 granule
  57.          extra_bits:  amount extra available from reservoir
  58.   Mark Taylor 4/99
  59. */
  60. void ResvMaxBits(lame_global_flags *gfp, int mean_bits, int *targ_bits, int *extra_bits)
  61. {
  62.   lame_internal_flags *gfc=gfp->internal_flags;
  63.   int add_bits,full_fac;
  64.   *targ_bits = mean_bits ;
  65.  
  66.  
  67.   /* extra bits if the reservoir is almost full */
  68.   full_fac=9;
  69.   if (gfc->ResvSize > ((gfc->ResvMax * full_fac) / 10)) {
  70.     add_bits= gfc->ResvSize-((gfc->ResvMax * full_fac) / 10);
  71.     *targ_bits += add_bits;
  72.   }else {
  73.     add_bits =0 ;
  74.     /* build up reservoir.  this builds the reservoir a little slower
  75.      * than FhG.  It could simple be mean_bits/15, but this was rigged
  76.      * to always produce 100 (the old value) at 128kbs */
  77.     /*    *targ_bits -= (int) (mean_bits/15.2);*/
  78.     *targ_bits -= .1*mean_bits;
  79.   }
  80.  
  81.  
  82.   /* amount from the reservoir we are allowed to use. ISO says 6/10 */
  83.   *extra_bits =
  84.     (gfc->ResvSize  < (gfc->ResvMax*6)/10  ? gfc->ResvSize : (gfc->ResvMax*6)/10);
  85.   *extra_bits -= add_bits;
  86.  
  87.   if (*extra_bits < 0) *extra_bits=0;
  88.  
  89.  
  90. }
  91.  
  92. /*
  93.   ResvAdjust:
  94.   Called after a granule's bit allocation. Readjusts the size of
  95.   the reservoir to reflect the granule's usage.
  96. */
  97. void
  98. ResvAdjust(lame_global_flags *gfp,gr_info *gi, III_side_info_t *l3_side, int mean_bits )
  99. {
  100.   lame_internal_flags *gfc=gfp->internal_flags;
  101.   gfc->ResvSize += (mean_bits / gfc->stereo) - gi->part2_3_length;
  102. #if 0
  103.   printf("part2_3_length:  %i  avg=%i  incres: %i\n",gi->part2_3_length,
  104.      mean_bits/gfc->stereo,
  105. mean_bits/gfc->stereo-gi->part2_3_length);
  106. #endif
  107. }
  108.  
  109.  
  110. /*
  111.   ResvFrameEnd:
  112.   Called after all granules in a frame have been allocated. Makes sure
  113.   that the reservoir size is within limits, possibly by adding stuffing
  114.   bits.
  115. */
  116. void
  117. ResvFrameEnd(lame_global_flags *gfp,III_side_info_t *l3_side, int mean_bits)
  118. {
  119.     int stuffingBits;
  120.     int over_bits;
  121.     lame_internal_flags *gfc=gfp->internal_flags;
  122.  
  123.  
  124.     /* just in case mean_bits is odd, this is necessary... */
  125.     if ( gfc->stereo == 2 && mean_bits & 1)
  126.     gfc->ResvSize += 1;
  127.  
  128.     stuffingBits=0;
  129.     l3_side->resvDrain_post = 0;
  130.     l3_side->resvDrain_pre = 0;
  131.  
  132.     /* we must be byte aligned */
  133.     if ( (over_bits = (gfc->ResvSize % 8)) )
  134.     stuffingBits += over_bits;
  135.  
  136.  
  137.     over_bits = (gfc->ResvSize - stuffingBits) - gfc->ResvMax;
  138.     if (over_bits > 0) {
  139.       assert(0==(over_bits % 8 ));
  140.       stuffingBits += over_bits;
  141.     }
  142.  
  143.  
  144. #define NEW_DRAINXX
  145. #ifdef NEW_DRAIN
  146.     /* drain as many bits as possible into previous frame ancillary data
  147.      * In particular, in VBR mode ResvMax may have changed, and we have
  148.      * to make sure main_data_begin does not create a reservoir bigger
  149.      * than ResvMax  mt 4/00*/
  150.   {
  151.     int mdb_bytes = Min(l3_side->main_data_begin*8,stuffingBits)/8;
  152.     l3_side->resvDrain_pre += 8*mdb_bytes;
  153.     stuffingBits -= 8*mdb_bytes;
  154.     gfc->ResvSize -= 8*mdb_bytes;
  155.     l3_side->main_data_begin -= mdb_bytes;
  156.  
  157.  
  158.     /* drain just enough to be byte aligned.  The remaining bits will
  159.      * be added to the reservoir, and we will deal with them next frame.
  160.      * If the next frame is at a lower bitrate, it may have a larger ResvMax,
  161.      * and we will not have to waste these bits!  mt 4/00 */
  162.     l3_side->resvDrain_post += (stuffingBits % 8);
  163.     gfc->ResvSize -= stuffingBits % 8;
  164.   }
  165. #else
  166.     /* drain the rest into this frames ancillary data*/
  167.     l3_side->resvDrain_post += stuffingBits;
  168.     gfc->ResvSize -= stuffingBits;
  169. #endif
  170.  
  171.     return;
  172. }
  173.  
  174.  
  175.